package com.ruoyi.business.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.business.mapper.WsdRoleClassMapper;
import com.ruoyi.business.service.IWsdRoleClassService;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.WsdRoleClass;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysRoleService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import static com.ruoyi.common.utils.SecurityUtils.getLoginUser;

/**
 * 角色与班级绑定Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-05-09
 */
@Service
@Slf4j
public class WsdRoleClassServiceImpl extends ServiceImpl<WsdRoleClassMapper, WsdRoleClass>  implements IWsdRoleClassService
{
    @Autowired
    private WsdRoleClassMapper wsdRoleClassMapper;

    @Autowired
    private ISysRoleService roleService;

    /**
     * 查询角色与班级绑定
     * 
     * @param id 角色与班级绑定主键
     * @return 角色与班级绑定
     */
    @Override
    public WsdRoleClass selectWsdRoleClassById(Long id)
    {
        return wsdRoleClassMapper.selectWsdRoleClassById(id);
    }

    /**
     * 查询角色与班级绑定列表
     * 
     * @param wsdRoleClass 角色与班级绑定
     * @return 角色与班级绑定
     */
    @Override
    public List<WsdRoleClass> selectWsdRoleClassList(WsdRoleClass wsdRoleClass) {
        return wsdRoleClassMapper.selectWsdRoleClassList(wsdRoleClass);
    }

    /**
     * 新增角色与班级绑定
     * 
     * @param wsdRoleClass 角色与班级绑定
     * @return 结果
     */
    @Override
    public int insertWsdRoleClass(WsdRoleClass wsdRoleClass) {
        return wsdRoleClassMapper.insertWsdRoleClass(wsdRoleClass);
    }

    /**
     * 修改角色与班级绑定
     *
     * @param wsdRoleClass 角色与班级绑定
     * @return 结果
     */
    @Override
    public boolean updateWsdRoleClass(WsdRoleClass wsdRoleClass) {
        List<WsdRoleClass> wsdRoleClasses = new ArrayList<>();
        //把原来的数据进行删除
        LambdaQueryWrapper<WsdRoleClass> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(WsdRoleClass::getRoleId,wsdRoleClass.getRoleId());
        wsdRoleClassMapper.delete(wrapper);
        //再批量新增
        Long[] classIds = wsdRoleClass.getClassIds();
        for (Long classId : classIds) {
            WsdRoleClass wsdRoleClass1 = new WsdRoleClass();
            wsdRoleClass1.setRoleId(wsdRoleClass.getRoleId());
            wsdRoleClass1.setClassId(classId);
            wsdRoleClasses.add(wsdRoleClass1);
        }
        return this.saveBatch(wsdRoleClasses);
    }

    /**
     * 批量删除角色与班级绑定
     * 
     * @param ids 需要删除的角色与班级绑定主键
     * @return 结果
     */
    @Override
    public int deleteWsdRoleClassByIds(Long[] ids)
    {
        return wsdRoleClassMapper.deleteWsdRoleClassByIds(ids);
    }

    /**
     * 删除角色与班级绑定信息
     * 
     * @param id 角色与班级绑定主键
     * @return 结果
     */
    @Override
    public int deleteWsdRoleClassById(Long id)
    {
        return wsdRoleClassMapper.deleteWsdRoleClassById(id);
    }

    /**
     * 查询角色与班级绑定的id
     *
     * @param
     * @return
     */
    @Override
    public WsdRoleClass queryList() {
        List<Long> classIds = new ArrayList<>();
        // 初始化为一个空列表，以避免 NullPointerException 的风险

        SysUser user = getLoginUser().getUser();
        List<SysRole> sysRoles = roleService.selectRolesUserByUserId(user.getUserId());

        if (ObjectUtils.isEmpty(sysRoles)) {
            // 用户未配置角色，记录日志并抛出异常
            log.error("用户未配置角色: userId={}", user.getUserId());
            throw new RuntimeException("你还没有配置角色,请联系管理员");
        } else {
            List<Long> roleIds = sysRoles.stream()
                    .map(SysRole::getRoleId)
                    .collect(Collectors.toList());

            LambdaQueryWrapper<WsdRoleClass> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(WsdRoleClass::getRoleId, roleIds);
            List<WsdRoleClass> wsdRoleClassList = this.list(wrapper);

            if (!wsdRoleClassList.isEmpty()) {
                classIds = wsdRoleClassList.stream().map(WsdRoleClass::getClassId).collect(Collectors.toList());
            } else {
                // 用户未绑定班级，记录日志并抛出异常
                log.error("用户未绑定班级: userId={}, roleIds={}", user.getUserId(), roleIds);
                throw new RuntimeException("你还没有绑定班级");
            }
        }

        WsdRoleClass wsdRoleClass = new WsdRoleClass();
        wsdRoleClass.setClassIds( classIds.toArray(new Long[classIds.size()])); // 使用简洁的方式转换列表为数组
        return wsdRoleClass;
    }
}
